function EWA_JSONXmlClass() {
	this._JSon = new EWA_JSONClass();
	this.toJSON = function(xmlNode) {
		return this.createNode(xmlNode);
	}
	this.createNode = function(node) {
		var s = [];
		s.push(this._JSon.ToJSONString(node.tagName));
		s.push(": {");
		for (var i = 0; i < node.attributes.length; i++) {
			var att = node.attributes[i];
			var s1 = this.createAttribute(att);
			if (i > 0) {
				s.push(",")
			}
			s.push(s1)
		}

		for (var i = 0; i < node.childNodes.length; i++) {
			if (i > 0 || node.attributes.length > 0)
				s.push(",\r\n");
			s.push(this.createNode(node.childNodes[i]));
		}

		s.push("}");

		return s.join(" ");
	}
	this.createAttribute = function(att) {
		var s = [];
		s.push(this._JSon.ToJSONString(att.name));
		s.push(":");
		s.push(this._JSon.ToJSONString(att.value));
		return s.join(" ");
	}
}

function EWA_JSONClass() {
	this._Escapeable = /["\\\x00-\x1f\x7f-\x9f]/g;
	this._Meta = {
		'\b' : '\\b',
		'\t' : '\\t',
		'\n' : '\\n',
		'\f' : '\\f',
		'\r' : '\\r',
		'"' : '\\"',
		'\\' : '\\\\'
	};
	this.ToJSONDate = function(date) {
		if (date == null) {
			return 'null';
		}
		return date.getUTCFullYear() + '-' + f(date.getUTCMonth() + 1) + '-' + f(date.getUTCDate()) + 'T' + f(date.getUTCHours())
			+ ':' + f(date.getUTCMinutes()) + ':' + f(date.getUTCSeconds()) + 'Z';

	};
	this.ToJSONString = function(s) {
		var s1;
		if (this._Escapeable.test(s)) {
			s1 = s.replace(escapeable, function(a) {
				var c = meta[a];
				if (typeof c === 'string') {
					return c;
				}
				c = a.charCodeAt();
				return '\\u00' + Math.floor(c / 16).toString(16) + (c % 16).toString(16);
			})
		} else {
			s1 = s;
		}
		s1 = '"' + s1 + '"';
		return s1;
	};
	this.ToJSONArray = function(arr) {
		var length = arr.length;
		var s = [];
		for (var i = 0; i < length; i += 1) {
			s[i] = this.ToJSON(arr[i]);
		}
		var v = s.length === 0 ? '[]' : '[' + s.join(', ') + ']';
		return v;
	};
	this.ToJSONObject = function(obj) {
		var key, val, s = [];
		for (key in obj) {
			val = obj[key];
			if (key == 'parent' || key.substring(0, 1) == "_" || val == null || val instanceof Function) {
				continue;
			}
			var s0 = this.ToJSONString(key) + ": ";
			var t1 = typeof val;
			if (t1 === 'string' || t1 === 'number' || t1 === 'boolean' || val instanceof Date) {
				s.push(s0 + this.ToJSON(val));
			} else if (t1 === 'object') {
				s.push(s0 + this.ToJSON(val));
			}
		}
		return s.length === 0 ? "{}" : "{" + s.join(', ') + "}";
	}
	this.ToJSON = function(obj) {
		var t = typeof obj;
		if (obj instanceof Date) {
			return this.ToJSONDate(obj);
		} else if (t === 'string') {
			return this.ToJSONString(obj);
		} else if (t === 'number') {
			return isFinite(obj) ? String(obj) : 'null';
		} else if (t === 'boolean' || t === 'null') {
			return String(obj);
		} else if (t === 'object') {
			if (typeof obj.length === 'number' && !obj.propertyIsEnumerable('length')) {
				return this.ToJSONArray(obj);
			} else {
				return this.ToJSONObject(obj);
			}
		}
	};

	this.Parse = function(str) {
		var o = eval('(' + str + ')');
		return o;
	};
}

JSON = window.JSON
	|| function() {

		function f(n) { // Format integers to have at least two digits.
			return n < 10 ? '0' + n : n;
		}

		Date.prototype.toJSON = function() {

			// Eventually, this method will be based on the date.toISOString
			// method.

			return this.getUTCFullYear() + '-' + f(this.getUTCMonth() + 1) + '-' + f(this.getUTCDate()) + 'T'
				+ f(this.getUTCHours()) + ':' + f(this.getUTCMinutes()) + ':' + f(this.getUTCSeconds()) + 'Z';
		};

		var escapeable = /["\\\x00-\x1f\x7f-\x9f]/g, gap, indent, meta = {
			'\b' : '\\b',
			'\t' : '\\t',
			'\n' : '\\n',
			'\f' : '\\f',
			'\r' : '\\r',
			'"' : '\\"',
			'\\' : '\\\\'
		}, rep;

		function quote(string) {
			return escapeable.test(string) ? '"' + string.replace(escapeable, function(a) {
				var c = meta[a];
				if (typeof c === 'string') {
					return c;
				}
				c = a.charCodeAt();
				return '\\u00' + Math.floor(c / 16).toString(16) + (c % 16).toString(16);
			}) + '"' : '"' + string + '"';
		}

		function str(key, holder) {
			var i, // The loop counter.
			k, // The member key.
			v, // The member value.
			length, mind = gap, partial, value = holder[key];

			if (value && typeof value === 'object' && typeof value.toJSON === 'function') {
				value = value.toJSON(key);
			}

			// If we were called with a replacer function, then call the
			// replacer to
			// obtain a replacement value.

			// if (typeof rep === 'function') {
			// value = rep.call(holder, key, value);
			// }

			// What happens next depends on the value's type.

			switch (typeof value) {
			case 'string':
				return quote(value);
			case 'number':
				return isFinite(value) ? String(value) : 'null';
			case 'boolean':
			case 'null':

				// If the value is a boolean or null, convert it to a
				// string. Note:
				// typeof null does not produce 'null'. The case is included
				// here in
				// the remote chance that this gets fixed someday.

				return String(value);

				// If the type is 'object', we might be dealing with an
				// object or an array or
				// null.

			case 'object':

				// Due to a specification blunder in ECMAScript, typeof null
				// is 'object',
				// so watch out for that case.

				if (!value) {
					return 'null';
				}

				// Make an array to hold the partial results of stringifying
				// this object value.

				gap += indent;
				partial = [];

				// If the object has a dontEnum length property, we'll treat
				// it as an array.

				if (typeof value.length === 'number' && !(value.propertyIsEnumerable('length'))) {

					// The object is an array. Stringify every element. Use
					// null as a placeholder
					// for non-JSON values.

					length = value.length;
					for (i = 0; i < length; i += 1) {
						partial[i] = str(i, value) || 'null';
					}

					// Join all of the elements together, separated with
					// commas, and wrap them in
					// brackets.

					v = partial.length === 0 ? '[]' : gap ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' : '['
						+ partial.join(',') + ']';
					gap = mind;
					return v;
				}

				// If the replacer is an array, use it to select the members
				// to be stringified.

				if (typeof rep === 'object') {
					length = rep.length;
					for (i = 0; i < length; i += 1) {
						k = rep[i];
						if (typeof k === 'string') {
							v = str(k, value, rep);
							if (v) {
								partial.push(quote(k) + (gap ? ': ' : ':') + v);
							}
						}
					}
				} else {

					// Otherwise, iterate through all of the keys in the
					// object.

					for (k in value) {
						v = str(k, value, rep);
						if (v) {
							partial.push(quote(k) + (gap ? ': ' : ':') + v);
						}
					}
				}

				// Join all of the member texts together, separated with
				// commas,
				// and wrap them in braces.

				v = partial.length === 0 ? '{}' : gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' : '{'
					+ partial.join(',') + '}';
				gap = mind;
				return v;
			}
		}

		// Return the JSON object containing the stringify, parse, and quote
		// methods.

		return {
			stringify : function(value, replacer, space) {

				// The stringify method takes a value and an optional
				// replacer,
				// and an optional
				// space parameter, and returns a JSON text. The replacer
				// can be
				// a function
				// that can replace values, or an array of strings that will
				// select the keys.
				// A default replacer method can be provided. Use of the
				// space
				// parameter can
				// produce text that is more easily readable.

				var i;
				gap = '';
				indent = '';
				if (space) {

					// If the space parameter is a number, make an indent
					// string
					// containing that
					// many spaces.

					if (typeof space === 'number') {
						for (i = 0; i < space; i += 1) {
							indent += ' ';
						}

						// If the space parameter is a string, it will be
						// used
						// as the indent string.

					} else if (typeof space === 'string') {
						indent = space;
					}
				}

				// If there is no replacer parameter, use the default
				// replacer.

				if (!replacer) {
					rep = function(key, value) {
						if (!Object.hasOwnProperty.call(this, key)) {
							return undefined;
						}
						return value;
					};

					// The replacer can be a function or an array.
					// Otherwise,
					// throw an error.

				} else if (typeof replacer === 'function'
					|| (typeof replacer === 'object' && typeof replacer.length === 'number')) {
					rep = replacer;
				} else {
					throw new Error('JSON.stringify');
				}

				// Make a fake root object containing our value under the
				// key of
				// ''.
				// Return the result of stringifying the value.

				return str('', {
					'' : value
				});
			},

			parse : function(text, reviver) {

				// The parse method takes a text and an optional reviver
				// function, and returns
				// a JavaScript value if the text is a valid JSON text.

				var j;

				function walk(holder, key) {

					// The walk method is used to recursively walk the
					// resulting
					// structure so
					// that modifications can be made.

					var k, v, value = holder[key];
					if (value && typeof value === 'object') {
						for (k in value) {
							if (Object.hasOwnProperty.call(value, k)) {
								v = walk(value, k);
								if (v !== undefined) {
									value[k] = v;
								} else {
									delete value[k];
								}
							}
						}
					}
					return reviver.call(holder, key, value);
				}

				// Parsing happens in three stages. In the first stage, we
				// run
				// the text against
				// regular expressions that look for non-JSON patterns. We
				// are
				// especially
				// concerned with '()' and 'new' because they can cause
				// invocation, and '='
				// because it can cause mutation. But just to be safe, we
				// want
				// to reject all
				// unexpected forms.

				// We split the first stage into 4 regexp operations in
				// order to
				// work around
				// crippling inefficiencies in IE's and Safari's regexp
				// engines.
				// First we
				// replace all backslash pairs with '@' (a non-JSON
				// character).
				// Second, we
				// replace all simple value tokens with ']' characters.
				// Third,
				// we delete all
				// open brackets that follow a colon or comma or that begin
				// the
				// text. Finally,
				// we look to see that the remaining characters are only
				// whitespace or ']' or
				// ',' or ':' or '{' or '}'. If that is so, then the text is
				// safe for eval.

				if (/^[\],:{}\s]*$/.test(text.replace(/\\["\\\/bfnrtu]/g, '@').replace(
					/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {

					// In the second stage we use the eval function to
					// compile
					// the text into a
					// JavaScript structure. The '{' operator is subject to
					// a
					// syntactic ambiguity
					// in JavaScript: it can begin a block or an object
					// literal.
					// We wrap the text
					// in parens to eliminate the ambiguity.

					j = eval('(' + text + ')');

					// In the optional third stage, we recursively walk the
					// new
					// structure, passing
					// each name/value pair to a reviver function for
					// possible
					// transformation.

					return typeof reviver === 'function' ? walk({
						'' : j
					}, '') : j;
				}

				// If the text is not JSON parseable, then a SyntaxError is
				// thrown.

				throw new SyntaxError('JSON.parse');
			},

			quote : quote
		};
	}();
EWA.JSON = JSON;